package modelo;

import java.util.ArrayList;

/**
 * Created by Usuario on 02/11/2014.
 */
public class MatrizBase implements MatrizInterface {
    ArrayList<Comparacion> matrizBase;
    ArrayList<Item> itemsComparados;

    public MatrizBase() {
        matrizBase = new ArrayList<Comparacion>();
        itemsComparados = new ArrayList<Item>();
    }

    public MatrizBase(ArrayList<Item> itemsComparados) {
        this.itemsComparados = itemsComparados;
    }

    /**
     * Método para compara dos términos. Hace la comparación directa primero y la inversa después.
     * Si son los dos iguales, asigna el puntaje a 1.
     * @param primerTermino
     * @param segundoTermino
     * @param puntaje
     */
    @Override
    public void comparar(Item primerTermino, Item segundoTermino, double puntaje) {
        if(primerTermino == segundoTermino) puntaje = 1.0;
        for (Comparacion comp : matrizBase) {
            if (comp.getPrimerTermino() == primerTermino && comp.getSegundoTermino() == segundoTermino){
                comp.setPuntaje(puntaje);
            }
            if (comp.getSegundoTermino() == primerTermino && comp.getPrimerTermino()== segundoTermino){
                comp.setPuntaje(1/puntaje); //seteo el inverso
            }
        }
    }


    /**
     * Suma cada una de las columnas de la matriz.
     * El total se almacena en un arreglo que luego sirve para
     * normalizar la matriz. Recorremos la matriz, tomamos como pivot el segundo término.
     * @param band TRVE si suma columnas, FALSE si suma filas
     * @return
     */
    @Override
    public ArrayList<Double> sumarFilasColumnas(boolean band) {
        ArrayList sumaCol = new ArrayList();

        for (Item i : itemsComparados){ //Buscarmos el acumulado para cada item.
            double acu = 0; // Inicializo el acumulador.
            for (Comparacion c : matrizBase){ // Voy recorriendo todas las comparaciones.
                if (band == true && c.getSegundoTermino() == i){
                    acu+= c.getPuntaje(); //suma columnas
                }
                if (band == false && c.getPrimerTermino() == i){
                    acu+= c.getPuntaje(); // suma filas
                }
            } // Termina de recorrer la matriz.

            sumaCol.add(acu); // Agrego el acumulador.
        } // Termino de sumar las columnas.

        return sumaCol;
    }

    /**
     * Método para crear la matriz de comparaciones.
     * Se debe ejecutar una vez creada la lista de TODOS los
     */
    @Override
    public void inicializarMatriz(){
        matrizBase = new ArrayList<Comparacion>();
        int idComp = 0;


        for (Item primTerm : itemsComparados){

            for (Item segTerm : itemsComparados){
                double puntaje = 0;
                if (primTerm == segTerm)
                    puntaje = 1;
                Comparacion comp = new Comparacion(idComp,primTerm,segTerm,puntaje); //Creo la comparación con puntaje 0.
                matrizBase.add(comp); // La agrego
                idComp++;

            }
        } // Recorro la lista armando la matriz con los dos for.
    }

    public ArrayList<Comparacion> getMatrizBase() {
        return matrizBase;
    }

    public void setMatrizBase(ArrayList<Comparacion> matrizBase) {
        this.matrizBase = matrizBase;
    }

    public ArrayList<Item> getItemsComparados() {
        return itemsComparados;
    }

    public void setItemsComparados(ArrayList<Item> itemsComparados) {
        this.itemsComparados = itemsComparados;
    }

    @Override
    public int cantidadItemsComparados() {
        return itemsComparados.size();
    }

    @Override
    public ArrayList<Double> calcularPesosRelativos() {
        return null;
    }

    /**
     * Método para multiplciar dos matrices.
     * @param pesosRelativos
     * @return
     */
    @Override
    public ArrayList<Double> prodAW(ArrayList<Double> pesosRelativos){
        ArrayList<Double> resultados = new ArrayList<Double>();

        for(Item c: itemsComparados){ //Me paro en un criterio.
            int indMuliplicador = 0; // ìndice que se va moviendo para multiplicar.
            double productoAW = 0; //Resultado de la multiplicaciòn de cada fila

            //Recorro toda la matriz de comparaciones.
            for (Comparacion comp: matrizBase){
                if(comp.getPrimerTermino() == c){
                    productoAW+= (comp.getPuntaje()* pesosRelativos.get(indMuliplicador));
                    indMuliplicador++; //Adelanto para multiplcar por el siguiente.
                }
            }
            resultados.add(productoAW);
        }

        for (int i = 0; i < resultados.size(); i++) {
            resultados.set(i, resultados.get(i)/pesosRelativos.get(i));
        }

        return resultados;
    }

    /**
     * Agrego un nuevo item a la lista.
     * Le paso el nombre. El id lo construye con la cantidad de items de la lista.
     * @param nombre
     * @return
     */
    public boolean addItem(String nombre){

        Item it = new Item(itemsComparados.size(), nombre);
        return itemsComparados.add(it);
    }

    /**
     *
     * @param id
     * @return
     */
    public Item getItemById(int id){
        for(Item it : itemsComparados){
            if(it.getId()==id){
                return it;
            }
        }
        return null;
    }

    /**
     * Devuelve un item según el nombre que le pasemos.
     * @param nombre
     * @return
     */

    public Item getItemByNombre(String nombre){
        for(Item it: itemsComparados){
            if(it.getNombre().equalsIgnoreCase(nombre))
                return it;
        }
        return null;
    }
}
